home *** CD-ROM | disk | FTP | other *** search
/ Info-Mac 3 / Info_Mac_1994-01.iso / Text Processing / Change Charset / ChangeCharSet.c < prev    next >
C/C++ Source or Header  |  1993-08-15  |  8KB  |  418 lines
  1. #include <SetupA4.h>
  2. #include "ExternalInterface.h"
  3. #include "DialogUtilities.h"
  4.  
  5.  
  6. #define MAC2ISO    2
  7. #define MAC2SCAND    3
  8. #define ISO2MAC    10
  9. #define SCAND2MAC    11
  10. #define INPLACE    4
  11. #define NEWWIN    5
  12. #define CLIPB    6
  13. #define CANCEL    9
  14. #define CONVERT    1
  15.  
  16. static void Convert2Scand(Handle text, long start, long end, long offset);
  17. static void Convert2ISO(Handle text, long start, long end, long offset);
  18. static void ConvertISO2Mac(Handle text, long start, long end, long offset);
  19. static void ConvertScand2Mac(Handle text, long start, long end, long offset);
  20.  
  21. static struct _charsetoptions
  22. {
  23.     enum {Mac2ISO, Mac2Scand, ISO2Mac, Scand2Mac} conversion;
  24.     enum {inPlace, newWin, clipBoard} destination;
  25. } charsetOptions;
  26.  
  27. static Boolean nonEmptySelection;
  28.  
  29. void maintainButtons(DialogPtr d)
  30. {
  31.     SetDlgCtl(d, MAC2ISO, charsetOptions.conversion == Mac2ISO);
  32.     SetDlgCtl(d, MAC2SCAND, charsetOptions.conversion == Mac2Scand);
  33.     SetDlgCtl(d, ISO2MAC, charsetOptions.conversion == ISO2Mac);
  34.     SetDlgCtl(d, SCAND2MAC, charsetOptions.conversion == Scand2Mac);
  35.  
  36.     SetDlgCtl(d, INPLACE, charsetOptions.destination == inPlace);
  37.     SetDlgCtl(d, NEWWIN, charsetOptions.destination == newWin);
  38.     SetDlgCtl(d, CLIPB, charsetOptions.destination == clipBoard);
  39. }
  40.  
  41. pascal void main(ExternalCallbackBlock *callbacks, WindowPtr w)
  42. {
  43.     DialogPtr d;
  44.     short item;
  45.     GrafPtr save_port;
  46.     long selStart, selEnd, firstChar;
  47.     
  48.     short    act_len;
  49.     
  50.     OSErr err;
  51.     
  52.     RememberA0();
  53.     SetUpA4();
  54.     
  55.     callbacks->GetPreference('CCST', sizeof(struct _charsetoptions), &charsetOptions, &act_len);
  56.     
  57.     if (act_len < 0)
  58.     {
  59.         charsetOptions.conversion = Mac2ISO;
  60.         charsetOptions.destination = inPlace;
  61.     }
  62.     
  63.     GetPort(&save_port);
  64.     d = callbacks->CenterDialog(128);
  65.     SetPort(d);
  66.     
  67.     callbacks->GetSelection(&selStart, &selEnd, &firstChar);
  68.     nonEmptySelection = (selEnd > selStart);
  69.     
  70.     do
  71.     {
  72.         maintainButtons(d);
  73.         
  74.         ModalDialog(callbacks->StandardFilter, &item);
  75.         
  76.         switch (item)
  77.         {
  78.             case MAC2ISO:
  79.                 charsetOptions.conversion = Mac2ISO;
  80.                 break;
  81.             case MAC2SCAND:
  82.                 charsetOptions.conversion = Mac2Scand;
  83.                 break;
  84.             case ISO2MAC:
  85.                 charsetOptions.conversion = ISO2Mac;
  86.                 break;
  87.             case SCAND2MAC:
  88.                 charsetOptions.conversion = Scand2Mac;
  89.                 break;
  90.             case INPLACE:
  91.                 charsetOptions.destination = inPlace;
  92.                 break;
  93.             case NEWWIN:
  94.                 charsetOptions.destination = newWin;
  95.                 break;
  96.             case CLIPB:
  97.                 charsetOptions.destination = clipBoard;
  98.                 break;
  99.         }
  100.     } while ((item != CONVERT) && (item != CANCEL));
  101.     
  102.     DisposDialog(d);
  103.     SetPort(save_port);
  104.     
  105.     if (item == CONVERT)
  106.     {
  107.         Handle h, text;
  108.         long textLen;
  109.         long changeStart, changeEnd;
  110.         long offset;
  111.         long extendLengthBy;
  112.         WindowPtr wp;
  113.         
  114.         callbacks->SetPreference('CCST', sizeof(struct _charsetoptions), &charsetOptions, &act_len);
  115.         
  116.         h = callbacks->GetWindowContents(w);
  117.         textLen = GetHandleSize(h);
  118.         if (!nonEmptySelection) 
  119.             {
  120.                 changeStart = 0;
  121.                 changeEnd = textLen;
  122.             } 
  123.         else 
  124.             {
  125.                 changeStart = selStart;
  126.                 changeEnd = selEnd;
  127.             }
  128.  
  129.         if (charsetOptions.destination == clipBoard || charsetOptions.destination == newWin) {
  130.             text = callbacks->Allocate(changeEnd-changeStart, FALSE);
  131.             if (text == NULL) {
  132.                 callbacks->ReportOSError(memFullErr);
  133.                 goto done;
  134.             }
  135.             BlockMove(*h + changeStart, *text, changeEnd-changeStart);
  136.             offset = 0;
  137.         } else {
  138.             text = h;
  139.             offset = changeStart;
  140.         }
  141.         switch (charsetOptions.conversion) {
  142.             case Mac2ISO:
  143.                 Convert2ISO(text, changeStart, changeEnd, offset);
  144.                 break;
  145.             case Mac2Scand:
  146.                 Convert2Scand(text, changeStart, changeEnd, offset);
  147.                 break;
  148.             case ISO2Mac:
  149.                 ConvertISO2Mac(text, changeStart, changeEnd, offset);
  150.                 break;
  151.             case Scand2Mac:
  152.                 ConvertScand2Mac(text, changeStart, changeEnd, offset);
  153.                 break;
  154.         }
  155.         
  156.         if (charsetOptions.destination == inPlace) {
  157.             callbacks->ContentsChanged(w);
  158.             callbacks->SetSelection(selStart, selEnd, firstChar);
  159.         } else if (charsetOptions.destination == newWin) {
  160.             wp = callbacks->NewDocument();
  161.             callbacks->SetWindowContents(wp, text);
  162.             callbacks->SetSelection(selStart, selEnd, firstChar);
  163.             /* text-handle belongs to the new window, don't dispose */
  164.         } else {
  165.             HLock(text);
  166.             ZeroScrap();
  167.             PutScrap(changeEnd - changeStart, 'TEXT', *text);
  168.             DisposHandle(text); /* obsolete, free it */
  169.         }
  170.  
  171.     }
  172. done:
  173.     RestoreA4();
  174. }
  175.  
  176. static void Convert2ISO(Handle text, long start, long end, long offset)
  177. {
  178.     long len = end - start;
  179.     long i;
  180.     char *p = *text + offset;
  181.     
  182.     for (i = 0; i < len; i++)
  183.         switch (p[i]) {
  184.             case '\307':
  185.                 p[i] = '\253';
  186.                 break;
  187.             case '\310':
  188.                 p[i] = '\273';
  189.             case '\246':
  190.                 p[i] = '\266';
  191.                 break;
  192.             case '\244':
  193.                 p[i] = '\247';
  194.                 break;
  195.             case '\347':
  196.                 p[i] = '\301';
  197.                 break;
  198.             case '\207':
  199.                 p[i] = '\341';
  200.                 break;
  201.             case '\200':
  202.                 p[i] = '\304';
  203.                 break;
  204.             case '\212':
  205.                 p[i] = '\344';
  206.                 break;
  207.             case '\313':
  208.                 p[i] = '\300';
  209.                 break;
  210.             case '\210':
  211.                 p[i] = '\340';
  212.                 break;
  213.             case '\256':
  214.                 p[i] = '\306';
  215.                 break;
  216.             case '\276':
  217.                 p[i] = '\346';
  218.                 break;
  219.             case '\201':
  220.                 p[i] = '\305';
  221.                 break;
  222.             case '\214':
  223.                 p[i] = '\345';
  224.                 break;
  225.             case '\203':
  226.                 p[i] = '\311';
  227.                 break;
  228.             case '\216':
  229.                 p[i] = '\351';
  230.                 break;
  231.             case '\205':
  232.                 p[i] = '\326';
  233.                 break;
  234.             case '\232':
  235.                 p[i] = '\366';
  236.                 break;
  237.             case '\257':
  238.                 p[i] = '\330';
  239.                 break;
  240.             case '\277':
  241.                 p[i] = '\370';
  242.                 break;
  243.             case '\206':
  244.                 p[i] = '\334';
  245.                 break;
  246.             case '\237':
  247.                 p[i] = '\374';
  248.                 break;
  249.             default:
  250.                 break;
  251.         }
  252. }
  253.  
  254. static void ConvertISO2Mac(Handle text, long start, long end, long offset)
  255. {
  256.     long len = end - start;
  257.     long i;
  258.     char *p = *text + offset;
  259.     
  260.     for (i = 0; i < len; i++)
  261.         switch (p[i]) {
  262.             case '\253':
  263.                 p[i] = '\307';
  264.                 break;
  265.             case '\273':
  266.                 p[i] = '\310';
  267.             case '\266':
  268.                 p[i] = '\246';
  269.                 break;
  270.             case '\247':
  271.                 p[i] = '\244';
  272.                 break;
  273.             case '\301':
  274.                 p[i] = '\347';
  275.                 break;
  276.             case '\341':
  277.                 p[i] = '\207';
  278.                 break;
  279.             case '\304':
  280.                 p[i] = '\200';
  281.                 break;
  282.             case '\344':
  283.                 p[i] = '\212';
  284.                 break;
  285.             case '\300':
  286.                 p[i] = '\313';
  287.                 break;
  288.             case '\340':
  289.                 p[i] = '\210';
  290.                 break;
  291.             case '\306':
  292.                 p[i] = '\256';
  293.                 break;
  294.             case '\346':
  295.                 p[i] = '\276';
  296.                 break;
  297.             case '\305':
  298.                 p[i] = '\201';
  299.                 break;
  300.             case '\345':
  301.                 p[i] = '\214';
  302.                 break;
  303.             case '\311':
  304.                 p[i] = '\203';
  305.                 break;
  306.             case '\351':
  307.                 p[i] = '\216';
  308.                 break;
  309.             case '\326':
  310.                 p[i] = '\205';
  311.                 break;
  312.             case '\366':
  313.                 p[i] = '\232';
  314.                 break;
  315.             case '\330':
  316.                 p[i] = '\257';
  317.                 break;
  318.             case '\370':
  319.                 p[i] = '\277';
  320.                 break;
  321.             case '\334':
  322.                 p[i] = '\206';
  323.                 break;
  324.             case '\374':
  325.                 p[i] = '\237';
  326.                 break;
  327.             default:
  328.                 break;
  329.         }
  330. }
  331.  
  332.  
  333. static void Convert2Scand(Handle text, long start, long end, long offset)
  334. {
  335.     long len = end - start;
  336.     long i;
  337.     char *p = *text + offset;
  338.     
  339.     for (i = 0; i < len; i++)
  340.         switch (p[i]) {
  341.             case '\200':
  342.                 p[i] = '[';
  343.                 break;
  344.             case '\212':
  345.                 p[i] = '{';
  346.                 break;
  347.             case '\201':
  348.                 p[i] = ']';
  349.                 break;
  350.             case '\214':
  351.                 p[i] = '}';
  352.                 break;
  353.             case '\203':
  354.                 p[i] = '@';
  355.                 break;
  356.             case '\216':
  357.                 p[i] = '`';
  358.                 break;
  359.             case '\205':
  360.                 p[i] = '\\';
  361.                 break;
  362.             case '\232':
  363.                 p[i] = '|';
  364.                 break;
  365.             case '\334':
  366.                 p[i] = '^';
  367.                 break;
  368.             case '\374':
  369.                 p[i] = '~';
  370.                 break;
  371.             default:
  372.                 break;
  373.         }
  374. }
  375.  
  376. static void ConvertScand2Mac(Handle text, long start, long end, long offset)
  377. {
  378.     long len = end - start;
  379.     long i;
  380.     char *p = *text + offset;
  381.     
  382.     for (i = 0; i < len; i++)
  383.         switch (p[i]) {
  384.             case '[':
  385.                 p[i] = '\200';
  386.                 break;
  387.             case '{':
  388.                 p[i] = '\212';
  389.                 break;
  390.             case ']':
  391.                 p[i] = '\201';
  392.                 break;
  393.             case '}':
  394.                 p[i] = '\214';
  395.                 break;
  396.             case '@':
  397.                 p[i] = '\203';
  398.                 break;
  399.             case '`':
  400.                 p[i] = '\216';
  401.                 break;
  402.             case '\\':
  403.                 p[i] = '\205';
  404.                 break;
  405.             case '|':
  406.                 p[i] = '\232';
  407.                 break;
  408.             case '^':
  409.                 p[i] = '\334';
  410.                 break;
  411.             case '~':
  412.                 p[i] = '\374';
  413.                 break;
  414.             default:
  415.                 break;
  416.         }
  417. }
  418.